#include "Enemy.h"
#include "Globals.h" // 访问 enemies, bullets, player, enemyShootTimer 等
#include <math.h>    // 用于 sin/cos
#include <stdlib.h>  // 用于 rand
#include <stdio.h>   // 用于 printf 调试

// 生成一个新的敌机 (如果有名额)
void spawn_new_enemy(LevelConfig config) {
    if (activeEnemies >= MAX_ACTIVE_ENEMIES) {
        return; // 活动敌机已达上限
    }

    // 寻找一个非活动的敌机槽位
    for (int i = 0; i < MAX_TOTAL_ENEMIES; i++) {
        if (!enemies[i].isActive) { // 找到了
            enemies[i].isActive = true; // 激活
            // 在屏幕内随机 X 坐标
            enemies[i].x = static_cast<float>((rand() % (getwidth() - 100)) + 50);
            enemies[i].y = ENEMY_SPAWN_Y; // 从屏幕上方开始
            enemies[i].hp = config.enemy_hp; // 使用关卡配置的 HP
            enemies[i].score = 10 * config.level; // 基础分数

            // --- 决定敌机类型和属性 ---
            int enemyTypeRand = rand() % 100; // 生成 0-99 的随机数
            if (enemyTypeRand < 65) { // 65% 概率为基础类型
                enemies[i].type = 0;           // 类型 0
                enemies[i].num = rand() % 11;  // 图片 0-10
                enemies[i].speed = 1.5f + config.level * 0.2f; // 速度随关卡提升
            } else if (enemyTypeRand < 85) { // 20% 概率为正弦波类型
                enemies[i].type = 1;           // 类型 1
                enemies[i].num = 11;           // 图片 11
                enemies[i].speed = 2.0f + config.level * 0.3f;
                enemies[i].hp = (int)(config.enemy_hp * 1.2f); // HP 稍高
            } else { // 15% 概率为追踪型
                enemies[i].type = 3;           // 类型 3
                enemies[i].num = 13 + rand() % 8; // 图片 13-20
                enemies[i].speed = 2.5f + config.level * 0.4f; // 更快
                enemies[i].hp = (int)(config.enemy_hp * 0.8f); // HP 稍低
            }
            // 可以根据你的设计添加更多敌机类型...

            activeEnemies++; // 增加活动敌机计数
            // 给敌机射击添加随机初始延迟，避免同时生成同时射击
            enemyShootTimer[i] = GetTickCount64() + rand() % 500;
            // printf("生成敌机 %d (类型 %d) 位置 (%.1f, %.1f)\n", i, enemies[i].type, enemies[i].x, enemies[i].y); // 调试信息
            return; // 每次调用只生成一个
        }
    }
    // 如果循环结束还没找到空位 (理论上不应发生，因为有 activeEnemies < MAX_ACTIVE_ENEMIES 限制)
}

// 指定敌机发射子弹 (如果有名额)
void enemy_shoot(Enemy* enemy) {
     if (!enemy || !enemy->isActive) return;
     // 检查敌机图片是否有效
     if (enemy->num < 0 || enemy->num >= MAX_ENEMY_IMAGES || image_Enemy[enemy->num].getwidth() == 0) return;

    for (int i = 0; i < MAX_BULLETS; i++) {
        if (!bullets[i].active) {
            // 找到了可用槽位
            bullets[i].active = true; // 激活子弹
            bullets[i].owner = 1;     // 拥有者是敌人
            bullets[i].angle = 90.0f; // 向下 (90 度)

            // 计算子弹初始位置 (敌机中心下方)
             float enemyWidth = image_Enemy[enemy->num].getwidth(); // 修正
             float enemyHeight = image_Enemy[enemy->num].getheight(); // 修正
             bullets[i].x = enemy->x + enemyWidth / 2.0f;
             bullets[i].y = enemy->y + enemyHeight; // Start just below the enemy

            // 基础子弹属性 (之后可根据敌机类型调整)
            bullets[i].type = 1; // 基础敌人子弹类型
            bullets[i].num = 1;  // 基础敌人子弹图片索引
            bullets[i].speed = 5.0f + current_level * 0.5f; // 速度随关卡提升
            bullets[i].attack_power = 5 + current_level;   // 威力随关卡提升

            // --- 可选: 特定类型敌人的子弹属性 ---
            // switch (enemy->type) {
            //    case 1: bullets[i].speed *= 1.2f; break; // 例如类型1的子弹更快
            //    // ... 其他类型 ...
            // }
            // printf("敌机 %d (类型 %d) 发射子弹 %d\n", (int)(enemy - enemies), enemy->type, i); // 调试信息
            break; // 发射一颗子弹后退出循环
        }
    }
    // 如果找不到空槽位，本次射击不生效
}

// 更新所有活动敌机的状态（移动、射击、检查是否消失）
void update_enemies() {
    ULONGLONG currentTime = GetTickCount64(); // 获取当前时间
    // 计算基础射击间隔 (毫秒)，随关卡缩短，但有最小值
    float baseShootInterval = 1500.0f;
    float shootInterval = max(500.0f, baseShootInterval - current_level * 100.0f); // 最短0.5秒

    // 遍历所有可能的敌机槽位
    for (int i = 0; i < MAX_TOTAL_ENEMIES; i++) {
        if (enemies[i].isActive) {
             // 检查敌机图片是否有效，无效则跳过处理或设为 inactive
             if (enemies[i].num < 0 || enemies[i].num >= MAX_ENEMY_IMAGES || image_Enemy[enemies[i].num].getwidth() == 0) {
                 continue;
             }

            // --- 移动 ---
            switch (enemies[i].type) {
                case 0: // 直线向下
                    enemies[i].y += enemies[i].speed;
                    break;
                case 1: // 正弦波移动
                    enemies[i].y += enemies[i].speed;
                    // 加入基于索引的偏移量避免所有敌机同步晃动
                    enemies[i].x += sin((enemies[i].y + i * 20.0f) / 40.0f) * 2.5f; // 调整了参数
                    break;
                case 3: // 追踪型
                    // 计算敌机中心到玩家中心的向量
                    float dx = player.x - (enemies[i].x + image_Enemy[enemies[i].num].getwidth() / 2.0f);
                    float dy = player.y - (enemies[i].y + image_Enemy[enemies[i].num].getheight() / 2.0f);
                    float dist = sqrt(dx * dx + dy * dy); // 计算距离
                    if (dist > 1.0f) { // 避免除以零和在靠近时抖动
                        // 向玩家方向移动
                        enemies[i].x += (dx / dist) * enemies[i].speed;
                        enemies[i].y += (dy / dist) * enemies[i].speed;
                    }
                    break;
                // 添加其他移动类型...
            }

            // --- 水平边界检查 ---
            float enemyWidth = image_Enemy[enemies[i].num].getwidth(); // 获取宽度用于边界检查
            if (enemies[i].x < 0) enemies[i].x = 0; // 防止移出左边界
            if (enemies[i].x > getwidth() - enemyWidth) enemies[i].x = getwidth() - enemyWidth; // 防止移出右边界

            // --- 射击 ---
            if (enemies[i].type != 3) { // 追踪型不射击
                if (currentTime - enemyShootTimer[i] >= shootInterval) { // 检查射击间隔
                    if (rand() % 100 < 70) { // 70% 的概率射击
                        enemy_shoot(&enemies[i]); // 调用射击函数
                        enemyShootTimer[i] = currentTime; // 射击后重置计时器
                    } else {
                        // 本次未射击，稍微延迟下次判断时间以避免完美同步
                        enemyShootTimer[i] = currentTime - (ULONGLONG)(shootInterval * (rand() % 50 / 100.0f)); // 延迟 0-50% 间隔
                    }
                }
            }

            // --- 检查消失条件 ---
            bool despawn = false; // 标记是否需要消失
            // 1. 飞出屏幕下方
            if (enemies[i].y > getheight()) {
                despawn = true;
            }
            // 2. HP耗尽 (被子弹击中后HP<=0)
            else if (enemies[i].hp <= 0) {
                // 在这里奖励分数更可靠，因为碰撞检测只减 HP
                player.score += enemies[i].score;
                // TODO: 在此敌机位置触发爆炸效果
                printf("敌机 %d 因HP耗尽被摧毁。分数: %d\n", i, player.score); // 调试信息
                despawn = true;
            }

            // 如果需要消失
            if (despawn) {
                enemies[i].isActive = false; // 设置为非活动
                activeEnemies--;             // 减少活动敌机计数
                enemyShootTimer[i] = 0;      // 重置此槽位的射击计时器
            }
        } // end if (enemies[i].isActive)
    } // end for loop
}


// 示例实现: 根据图片编号范围映射到逻辑类型
int return_type(int num) {
    if (num >= 0 && num <= 10) return 0; // 基础
    if (num == 11) return 1;             // 正弦
    if (num >= 13 && num <= 20) return 3; // 追踪
    // 添加其他类型/图片的映射
    return 0; // 默认为基础类型
}